juce/source/extras/audio plugin host/Source/GraphEditorPanel.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-9 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../JuceLibraryCode/JuceHeader.h"
  27 #include "GraphEditorPanel.h"
  28 #include "InternalFilters.h"
  29 #include "MainHostWindow.h"
  30
  31
  32 //==============================================================================
  33 class PluginWindow;
  34 static Array <PluginWindow*> activePluginWindows;
  35
  36 PluginWindow::PluginWindow (Component* const uiComp,
  37                             AudioProcessorGraph::Node* owner_,
  38                             const bool isGeneric_)
  39     : DocumentWindow (uiComp->getName(), Colours::lightblue,
  40                       DocumentWindow::minimiseButton | DocumentWindow::closeButton),
  41       owner (owner_),
  42       isGeneric (isGeneric_)
  43 {
  44     setSize (400, 300);
  45
  46     setContentOwned (uiComp, true);
  47
  48     setTopLeftPosition (owner->properties.getWithDefault ("uiLastX", Random::getSystemRandom().nextInt (500)),
  49                         owner->properties.getWithDefault ("uiLastY", Random::getSystemRandom().nextInt (500)));
  50     setVisible (true);
  51
  52     activePluginWindows.add (this);
  53 }
  54
  55 void PluginWindow::closeCurrentlyOpenWindowsFor (const uint32 nodeId)
  56 {
  57     for (int i = activePluginWindows.size(); --i >= 0;)
  58         if (activePluginWindows.getUnchecked(i)->owner->nodeId == nodeId)
  59             delete activePluginWindows.getUnchecked(i);
  60 }
  61
  62 void PluginWindow::closeAllCurrentlyOpenWindows()
  63 {
  64     for (int i = activePluginWindows.size(); --i >= 0;)
  65         delete activePluginWindows.getUnchecked(i);
  66 }
  67
  68 PluginWindow* PluginWindow::getWindowFor (AudioProcessorGraph::Node* node,
  69                                           bool useGenericView)
  70 {
  71     for (int i = activePluginWindows.size(); --i >= 0;)
  72         if (activePluginWindows.getUnchecked(i)->owner == node
  73              && activePluginWindows.getUnchecked(i)->isGeneric == useGenericView)
  74             return activePluginWindows.getUnchecked(i);
  75
  76     AudioProcessorEditor* ui = nullptr;
  77
  78     if (! useGenericView)
  79     {
  80         ui = node->getProcessor()->createEditorIfNeeded();
  81
  82         if (ui == nullptr)
  83             useGenericView = true;
  84     }
  85
  86     if (useGenericView)
  87     {
  88         ui = new GenericAudioProcessorEditor (node->getProcessor());
  89     }
  90
  91     if (ui != nullptr)
  92     {
  93         AudioPluginInstance* const plugin = dynamic_cast <AudioPluginInstance*> (node->getProcessor());
  94
  95         if (plugin != nullptr)
  96             ui->setName (plugin->getName());
  97
  98         return new PluginWindow (ui, node, useGenericView);
  99     }
 100
 101     return nullptr;
 102 }
 103
 104 PluginWindow::~PluginWindow()
 105 {
 106     activePluginWindows.removeValue (this);
 107     clearContentComponent();
 108 }
 109
 110 void PluginWindow::moved()
 111 {
 112     owner->properties.set ("uiLastX", getX());
 113     owner->properties.set ("uiLastY", getY());
 114 }
 115
 116 void PluginWindow::closeButtonPressed()
 117 {
 118     delete this;
 119 }
 120
 121 //==============================================================================
 122 class PinComponent   : public Component,
 123                        public SettableTooltipClient
 124 {
 125 public:
 126     PinComponent (FilterGraph& graph_,
 127                   const uint32 filterID_, const int index_, const bool isInput_)
 128         : filterID (filterID_),
 129           index (index_),
 130           isInput (isInput_),
 131           graph (graph_)
 132     {
 133         const AudioProcessorGraph::Node::Ptr node (graph.getNodeForId (filterID_));
 134
 135         if (node != nullptr)
 136         {
 137             String tip;
 138
 139             if (isInput)
 140                 tip = node->getProcessor()->getInputChannelName (index_);
 141             else
 142                 tip = node->getProcessor()->getOutputChannelName (index_);
 143
 144             if (tip.isEmpty())
 145             {
 146                 if (index_ == FilterGraph::midiChannelNumber)
 147                     tip = isInput ? "Midi Input" : "Midi Output";
 148                 else
 149                     tip = (isInput ? "Input " : "Output ") + String (index_ + 1);
 150             }
 151
 152             setTooltip (tip);
 153         }
 154
 155         setSize (16, 16);
 156     }
 157
 158     void paint (Graphics& g)
 159     {
 160         const float w = (float) getWidth();
 161         const float h = (float) getHeight();
 162
 163         Path p;
 164         p.addEllipse (w * 0.25f, h * 0.25f, w * 0.5f, h * 0.5f);
 165
 166         p.addRectangle (w * 0.4f, isInput ? (0.5f * h) : 0.0f, w * 0.2f, h * 0.5f);
 167
 168         g.setColour (index == FilterGraph::midiChannelNumber ? Colours::red : Colours::green);
 169         g.fillPath (p);
 170     }
 171
 172     void mouseDown (const MouseEvent& e)
 173     {
 174         getGraphPanel()->beginConnectorDrag (isInput ? 0 : filterID,
 175                                              index,
 176                                              isInput ? filterID : 0,
 177                                              index,
 178                                              e);
 179     }
 180
 181     void mouseDrag (const MouseEvent& e)
 182     {
 183         getGraphPanel()->dragConnector (e);
 184     }
 185
 186     void mouseUp (const MouseEvent& e)
 187     {
 188         getGraphPanel()->endDraggingConnector (e);
 189     }
 190
 191     const uint32 filterID;
 192     const int index;
 193     const bool isInput;
 194
 195 private:
 196     FilterGraph& graph;
 197
 198     GraphEditorPanel* getGraphPanel() const noexcept
 199     {
 200         return findParentComponentOfClass ((GraphEditorPanel*) nullptr);
 201     }
 202
 203     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (PinComponent);
 204 };
 205
 206 //==============================================================================
 207 class FilterComponent    : public Component
 208 {
 209 public:
 210     FilterComponent (FilterGraph& graph_,
 211                      const uint32 filterID_)
 212         : graph (graph_),
 213           filterID (filterID_),
 214           numInputs (0),
 215           numOutputs (0),
 216           pinSize (16),
 217           font (13.0f, Font::bold),
 218           numIns (0),
 219           numOuts (0)
 220     {
 221         shadow.setShadowProperties (2.5f, 0.5f, -1, 0);
 222         setComponentEffect (&shadow);
 223
 224         setSize (150, 60);
 225     }
 226
 227     ~FilterComponent()
 228     {
 229         deleteAllChildren();
 230     }
 231
 232     void mouseDown (const MouseEvent& e)
 233     {
 234         originalPos = localPointToGlobal (Point<int>());
 235
 236         toFront (true);
 237
 238         if (e.mods.isPopupMenu())
 239         {
 240             PopupMenu m;
 241             m.addItem (1, "Delete this filter");
 242             m.addItem (2, "Disconnect all pins");
 243             m.addSeparator();
 244             m.addItem (3, "Show plugin UI");
 245             m.addItem (4, "Show all parameters");
 246
 247             const int r = m.show();
 248
 249             if (r == 1)
 250             {
 251                 graph.removeFilter (filterID);
 252                 return;
 253             }
 254             else if (r == 2)
 255             {
 256                 graph.disconnectFilter (filterID);
 257             }
 258             else if (r == 3 || r == 4)
 259             {
 260                 AudioProcessorGraph::Node::Ptr f (graph.getNodeForId (filterID));
 261
 262                 if (f != nullptr)
 263                 {
 264                     PluginWindow* const w = PluginWindow::getWindowFor (f, r == 4);
 265
 266                     if (w != nullptr)
 267                         w->toFront (true);
 268                 }
 269             }
 270         }
 271     }
 272
 273     void mouseDrag (const MouseEvent& e)
 274     {
 275         if (! e.mods.isPopupMenu())
 276         {
 277             Point<int> pos (originalPos + Point<int> (e.getDistanceFromDragStartX(), e.getDistanceFromDragStartY()));
 278
 279             if (getParentComponent() != nullptr)
 280                 pos = getParentComponent()->getLocalPoint (nullptr, pos);
 281
 282             graph.setNodePosition (filterID,
 283                                    (pos.getX() + getWidth() / 2) / (double) getParentWidth(),
 284                                    (pos.getY() + getHeight() / 2) / (double) getParentHeight());
 285
 286             getGraphPanel()->updateComponents();
 287         }
 288     }
 289
 290     void mouseUp (const MouseEvent& e)
 291     {
 292         if (e.mouseWasClicked() && e.getNumberOfClicks() == 2)
 293         {
 294             const AudioProcessorGraph::Node::Ptr f (graph.getNodeForId (filterID));
 295
 296             if (f != nullptr)
 297             {
 298                 PluginWindow* const w = PluginWindow::getWindowFor (f, false);
 299
 300                 if (w != nullptr)
 301                     w->toFront (true);
 302             }
 303         }
 304         else if (! e.mouseWasClicked())
 305         {
 306             graph.setChangedFlag (true);
 307         }
 308     }
 309
 310     bool hitTest (int x, int y)
 311     {
 312         for (int i = getNumChildComponents(); --i >= 0;)
 313             if (getChildComponent(i)->getBounds().contains (x, y))
 314                 return true;
 315
 316         return x >= 3 && x < getWidth() - 6 && y >= pinSize && y < getHeight() - pinSize;
 317     }
 318
 319     void paint (Graphics& g)
 320     {
 321         g.setColour (Colours::lightgrey);
 322
 323         const int x = 4;
 324         const int y = pinSize;
 325         const int w = getWidth() - x * 2;
 326         const int h = getHeight() - pinSize * 2;
 327
 328         g.fillRect (x, y, w, h);
 329
 330         g.setColour (Colours::black);
 331         g.setFont (font);
 332         g.drawFittedText (getName(),
 333                           x + 4, y + 2, w - 8, h - 4,
 334                           Justification::centred, 2);
 335
 336         g.setColour (Colours::grey);
 337         g.drawRect (x, y, w, h);
 338     }
 339
 340     void resized()
 341     {
 342         for (int i = 0; i < getNumChildComponents(); ++i)
 343         {
 344             PinComponent* const pc = dynamic_cast <PinComponent*> (getChildComponent(i));
 345
 346             if (pc != nullptr)
 347             {
 348                 const int total = pc->isInput ? numIns : numOuts;
 349                 const int index = pc->index == FilterGraph::midiChannelNumber ? (total - 1) : pc->index;
 350
 351                 pc->setBounds (proportionOfWidth ((1 + index) / (total + 1.0f)) - pinSize / 2,
 352                                pc->isInput ? 0 : (getHeight() - pinSize),
 353                                pinSize, pinSize);
 354             }
 355         }
 356     }
 357
 358     void getPinPos (const int index, const bool isInput, float& x, float& y)
 359     {
 360         for (int i = 0; i < getNumChildComponents(); ++i)
 361         {
 362             PinComponent* const pc = dynamic_cast <PinComponent*> (getChildComponent(i));
 363
 364             if (pc != nullptr && pc->index == index && isInput == pc->isInput)
 365             {
 366                 x = getX() + pc->getX() + pc->getWidth() * 0.5f;
 367                 y = getY() + pc->getY() + pc->getHeight() * 0.5f;
 368                 break;
 369             }
 370         }
 371     }
 372
 373     void update()
 374     {
 375         const AudioProcessorGraph::Node::Ptr f (graph.getNodeForId (filterID));
 376
 377         if (f == nullptr)
 378         {
 379             delete this;
 380             return;
 381         }
 382
 383         numIns = f->getProcessor()->getNumInputChannels();
 384         if (f->getProcessor()->acceptsMidi())
 385             ++numIns;
 386
 387         numOuts = f->getProcessor()->getNumOutputChannels();
 388         if (f->getProcessor()->producesMidi())
 389             ++numOuts;
 390
 391         int w = 100;
 392         int h = 60;
 393
 394         w = jmax (w, (jmax (numIns, numOuts) + 1) * 20);
 395
 396         const int textWidth = font.getStringWidth (f->getProcessor()->getName());
 397         w = jmax (w, 16 + jmin (textWidth, 300));
 398         if (textWidth > 300)
 399             h = 100;
 400
 401         setSize (w, h);
 402
 403         setName (f->getProcessor()->getName());
 404
 405         {
 406             double x, y;
 407             graph.getNodePosition (filterID, x, y);
 408             setCentreRelative ((float) x, (float) y);
 409         }
 410
 411         if (numIns != numInputs || numOuts != numOutputs)
 412         {
 413             numInputs = numIns;
 414             numOutputs = numOuts;
 415
 416             deleteAllChildren();
 417
 418             int i;
 419             for (i = 0; i < f->getProcessor()->getNumInputChannels(); ++i)
 420                 addAndMakeVisible (new PinComponent (graph, filterID, i, true));
 421
 422             if (f->getProcessor()->acceptsMidi())
 423                 addAndMakeVisible (new PinComponent (graph, filterID, FilterGraph::midiChannelNumber, true));
 424
 425             for (i = 0; i < f->getProcessor()->getNumOutputChannels(); ++i)
 426                 addAndMakeVisible (new PinComponent (graph, filterID, i, false));
 427
 428             if (f->getProcessor()->producesMidi())
 429                 addAndMakeVisible (new PinComponent (graph, filterID, FilterGraph::midiChannelNumber, false));
 430
 431             resized();
 432         }
 433     }
 434
 435     FilterGraph& graph;
 436     const uint32 filterID;
 437     int numInputs, numOutputs;
 438
 439 private:
 440     int pinSize;
 441     Point<int> originalPos;
 442     Font font;
 443     int numIns, numOuts;
 444     DropShadowEffect shadow;
 445
 446     GraphEditorPanel* getGraphPanel() const noexcept
 447     {
 448         return findParentComponentOfClass ((GraphEditorPanel*) nullptr);
 449     }
 450
 451     FilterComponent (const FilterComponent&);
 452     FilterComponent& operator= (const FilterComponent&);
 453 };
 454
 455 //==============================================================================
 456 class ConnectorComponent   : public Component,
 457                              public SettableTooltipClient
 458 {
 459 public:
 460     ConnectorComponent (FilterGraph& graph_)
 461         : sourceFilterID (0),
 462           destFilterID (0),
 463           sourceFilterChannel (0),
 464           destFilterChannel (0),
 465           graph (graph_),
 466           lastInputX (0),
 467           lastInputY (0),
 468           lastOutputX (0),
 469           lastOutputY (0)
 470     {
 471         setAlwaysOnTop (true);
 472     }
 473
 474     ~ConnectorComponent()
 475     {
 476     }
 477
 478     void setInput (const uint32 sourceFilterID_, const int sourceFilterChannel_)
 479     {
 480         if (sourceFilterID != sourceFilterID_ || sourceFilterChannel != sourceFilterChannel_)
 481         {
 482             sourceFilterID = sourceFilterID_;
 483             sourceFilterChannel = sourceFilterChannel_;
 484             update();
 485         }
 486     }
 487
 488     void setOutput (const uint32 destFilterID_, const int destFilterChannel_)
 489     {
 490         if (destFilterID != destFilterID_ || destFilterChannel != destFilterChannel_)
 491         {
 492             destFilterID = destFilterID_;
 493             destFilterChannel = destFilterChannel_;
 494             update();
 495         }
 496     }
 497
 498     void dragStart (int x, int y)
 499     {
 500         lastInputX = (float) x;
 501         lastInputY = (float) y;
 502         resizeToFit();
 503     }
 504
 505     void dragEnd (int x, int y)
 506     {
 507         lastOutputX = (float) x;
 508         lastOutputY = (float) y;
 509         resizeToFit();
 510     }
 511
 512     void update()
 513     {
 514         float x1, y1, x2, y2;
 515         getPoints (x1, y1, x2, y2);
 516
 517         if (lastInputX != x1
 518              || lastInputY != y1
 519              || lastOutputX != x2
 520              || lastOutputY != y2)
 521         {
 522             resizeToFit();
 523         }
 524     }
 525
 526     void resizeToFit()
 527     {
 528         float x1, y1, x2, y2;
 529         getPoints (x1, y1, x2, y2);
 530
 531         const Rectangle<int> newBounds ((int) jmin (x1, x2) - 4,
 532                                         (int) jmin (y1, y2) - 4,
 533                                         (int) fabsf (x1 - x2) + 8,
 534                                         (int) fabsf (y1 - y2) + 8);
 535
 536         if (newBounds != getBounds())
 537             setBounds (newBounds);
 538         else
 539             resized();
 540
 541         repaint();
 542     }
 543
 544     void getPoints (float& x1, float& y1, float& x2, float& y2) const
 545     {
 546         x1 = lastInputX;
 547         y1 = lastInputY;
 548         x2 = lastOutputX;
 549         y2 = lastOutputY;
 550
 551         GraphEditorPanel* const hostPanel = getGraphPanel();
 552
 553         if (hostPanel != nullptr)
 554         {
 555             FilterComponent* srcFilterComp = hostPanel->getComponentForFilter (sourceFilterID);
 556
 557             if (srcFilterComp != nullptr)
 558                 srcFilterComp->getPinPos (sourceFilterChannel, false, x1, y1);
 559
 560             FilterComponent* dstFilterComp = hostPanel->getComponentForFilter (destFilterID);
 561
 562             if (dstFilterComp != nullptr)
 563                 dstFilterComp->getPinPos (destFilterChannel, true, x2, y2);
 564         }
 565     }
 566
 567     void paint (Graphics& g)
 568     {
 569         if (sourceFilterChannel == FilterGraph::midiChannelNumber
 570              || destFilterChannel == FilterGraph::midiChannelNumber)
 571         {
 572             g.setColour (Colours::red);
 573         }
 574         else
 575         {
 576             g.setColour (Colours::green);
 577         }
 578
 579         g.fillPath (linePath);
 580     }
 581
 582     bool hitTest (int x, int y)
 583     {
 584         if (hitPath.contains ((float) x, (float) y))
 585         {
 586             double distanceFromStart, distanceFromEnd;
 587             getDistancesFromEnds (x, y, distanceFromStart, distanceFromEnd);
 588
 589             // avoid clicking the connector when over a pin
 590             return distanceFromStart > 7.0 && distanceFromEnd > 7.0;
 591         }
 592
 593         return false;
 594     }
 595
 596     void mouseDown (const MouseEvent&)
 597     {
 598         dragging = false;
 599     }
 600
 601     void mouseDrag (const MouseEvent& e)
 602     {
 603         if ((! dragging) && ! e.mouseWasClicked())
 604         {
 605             dragging = true;
 606
 607             graph.removeConnection (sourceFilterID, sourceFilterChannel, destFilterID, destFilterChannel);
 608
 609             double distanceFromStart, distanceFromEnd;
 610             getDistancesFromEnds (e.x, e.y, distanceFromStart, distanceFromEnd);
 611             const bool isNearerSource = (distanceFromStart < distanceFromEnd);
 612
 613             getGraphPanel()->beginConnectorDrag (isNearerSource ? 0 : sourceFilterID,
 614                                                  sourceFilterChannel,
 615                                                  isNearerSource ? destFilterID : 0,
 616                                                  destFilterChannel,
 617                                                  e);
 618         }
 619         else if (dragging)
 620         {
 621             getGraphPanel()->dragConnector (e);
 622         }
 623     }
 624
 625     void mouseUp (const MouseEvent& e)
 626     {
 627         if (dragging)
 628             getGraphPanel()->endDraggingConnector (e);
 629     }
 630
 631     void resized()
 632     {
 633         float x1, y1, x2, y2;
 634         getPoints (x1, y1, x2, y2);
 635
 636         lastInputX = x1;
 637         lastInputY = y1;
 638         lastOutputX = x2;
 639         lastOutputY = y2;
 640
 641         x1 -= getX();
 642         y1 -= getY();
 643         x2 -= getX();
 644         y2 -= getY();
 645
 646         linePath.clear();
 647         linePath.startNewSubPath (x1, y1);
 648         linePath.cubicTo (x1, y1 + (y2 - y1) * 0.33f,
 649                           x2, y1 + (y2 - y1) * 0.66f,
 650                           x2, y2);
 651
 652         PathStrokeType wideStroke (8.0f);
 653         wideStroke.createStrokedPath (hitPath, linePath);
 654
 655         PathStrokeType stroke (2.5f);
 656         stroke.createStrokedPath (linePath, linePath);
 657
 658         const float arrowW = 5.0f;
 659         const float arrowL = 4.0f;
 660
 661         Path arrow;
 662         arrow.addTriangle (-arrowL, arrowW,
 663                            -arrowL, -arrowW,
 664                            arrowL, 0.0f);
 665
 666         arrow.applyTransform (AffineTransform::identity
 667                                 .rotated (float_Pi * 0.5f - (float) atan2 (x2 - x1, y2 - y1))
 668                                 .translated ((x1 + x2) * 0.5f,
 669                                              (y1 + y2) * 0.5f));
 670
 671         linePath.addPath (arrow);
 672         linePath.setUsingNonZeroWinding (true);
 673     }
 674
 675     uint32 sourceFilterID, destFilterID;
 676     int sourceFilterChannel, destFilterChannel;
 677
 678 private:
 679     FilterGraph& graph;
 680     float lastInputX, lastInputY, lastOutputX, lastOutputY;
 681     Path linePath, hitPath;
 682     bool dragging;
 683
 684     GraphEditorPanel* getGraphPanel() const noexcept
 685     {
 686         return findParentComponentOfClass ((GraphEditorPanel*) nullptr);
 687     }
 688
 689     void getDistancesFromEnds (int x, int y, double& distanceFromStart, double& distanceFromEnd) const
 690     {
 691         float x1, y1, x2, y2;
 692         getPoints (x1, y1, x2, y2);
 693
 694         distanceFromStart = juce_hypot (x - (x1 - getX()), y - (y1 - getY()));
 695         distanceFromEnd = juce_hypot (x - (x2 - getX()), y - (y2 - getY()));
 696     }
 697
 698     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ConnectorComponent);
 699 };
 700
 701
 702 //==============================================================================
 703 GraphEditorPanel::GraphEditorPanel (FilterGraph& graph_)
 704     : graph (graph_),
 705       draggingConnector (nullptr)
 706 {
 707     graph.addChangeListener (this);
 708     setOpaque (true);
 709 }
 710
 711 GraphEditorPanel::~GraphEditorPanel()
 712 {
 713     graph.removeChangeListener (this);
 714     deleteAndZero (draggingConnector);
 715     deleteAllChildren();
 716 }
 717
 718 void GraphEditorPanel::paint (Graphics& g)
 719 {
 720     g.fillAll (Colours::white);
 721 }
 722
 723 void GraphEditorPanel::mouseDown (const MouseEvent& e)
 724 {
 725     if (e.mods.isPopupMenu())
 726     {
 727         PopupMenu m;
 728
 729         MainHostWindow* const mainWindow = findParentComponentOfClass ((MainHostWindow*) nullptr);
 730
 731         if (mainWindow != nullptr)
 732         {
 733             mainWindow->addPluginsToMenu (m);
 734
 735             const int r = m.show();
 736
 737             createNewPlugin (mainWindow->getChosenType (r), e.x, e.y);
 738         }
 739     }
 740 }
 741
 742 void GraphEditorPanel::createNewPlugin (const PluginDescription* desc, int x, int y)
 743 {
 744     graph.addFilter (desc, x / (double) getWidth(), y / (double) getHeight());
 745 }
 746
 747 FilterComponent* GraphEditorPanel::getComponentForFilter (const uint32 filterID) const
 748 {
 749     for (int i = getNumChildComponents(); --i >= 0;)
 750     {
 751         FilterComponent* const fc = dynamic_cast <FilterComponent*> (getChildComponent (i));
 752
 753         if (fc != nullptr && fc->filterID == filterID)
 754             return fc;
 755     }
 756
 757     return nullptr;
 758 }
 759
 760 ConnectorComponent* GraphEditorPanel::getComponentForConnection (const AudioProcessorGraph::Connection& conn) const
 761 {
 762     for (int i = getNumChildComponents(); --i >= 0;)
 763     {
 764         ConnectorComponent* const c = dynamic_cast <ConnectorComponent*> (getChildComponent (i));
 765
 766         if (c != nullptr
 767              && c->sourceFilterID == conn.sourceNodeId
 768              && c->destFilterID == conn.destNodeId
 769              && c->sourceFilterChannel == conn.sourceChannelIndex
 770              && c->destFilterChannel == conn.destChannelIndex)
 771         {
 772             return c;
 773         }
 774     }
 775
 776     return nullptr;
 777 }
 778
 779 PinComponent* GraphEditorPanel::findPinAt (const int x, const int y) const
 780 {
 781     for (int i = getNumChildComponents(); --i >= 0;)
 782     {
 783         FilterComponent* const fc = dynamic_cast <FilterComponent*> (getChildComponent (i));
 784
 785         if (fc != nullptr)
 786         {
 787             PinComponent* const pin
 788                 = dynamic_cast <PinComponent*> (fc->getComponentAt (x - fc->getX(),
 789                                                                     y - fc->getY()));
 790
 791             if (pin != nullptr)
 792                 return pin;
 793         }
 794     }
 795
 796     return nullptr;
 797 }
 798
 799 void GraphEditorPanel::resized()
 800 {
 801     updateComponents();
 802 }
 803
 804 void GraphEditorPanel::changeListenerCallback (ChangeBroadcaster*)
 805 {
 806     updateComponents();
 807 }
 808
 809 void GraphEditorPanel::updateComponents()
 810 {
 811     int i;
 812     for (i = getNumChildComponents(); --i >= 0;)
 813     {
 814         FilterComponent* const fc = dynamic_cast <FilterComponent*> (getChildComponent (i));
 815
 816         if (fc != nullptr)
 817             fc->update();
 818     }
 819
 820     for (i = getNumChildComponents(); --i >= 0;)
 821     {
 822         ConnectorComponent* const cc = dynamic_cast <ConnectorComponent*> (getChildComponent (i));
 823
 824         if (cc != nullptr && cc != draggingConnector)
 825         {
 826             if (graph.getConnectionBetween (cc->sourceFilterID, cc->sourceFilterChannel,
 827                                             cc->destFilterID, cc->destFilterChannel) == nullptr)
 828             {
 829                 delete cc;
 830             }
 831             else
 832             {
 833                 cc->update();
 834             }
 835         }
 836     }
 837
 838     for (i = graph.getNumFilters(); --i >= 0;)
 839     {
 840         const AudioProcessorGraph::Node::Ptr f (graph.getNode (i));
 841
 842         if (getComponentForFilter (f->nodeId) == 0)
 843         {
 844             FilterComponent* const comp = new FilterComponent (graph, f->nodeId);
 845             addAndMakeVisible (comp);
 846             comp->update();
 847         }
 848     }
 849
 850     for (i = graph.getNumConnections(); --i >= 0;)
 851     {
 852         const AudioProcessorGraph::Connection* const c = graph.getConnection (i);
 853
 854         if (getComponentForConnection (*c) == 0)
 855         {
 856             ConnectorComponent* const comp = new ConnectorComponent (graph);
 857             addAndMakeVisible (comp);
 858
 859             comp->setInput (c->sourceNodeId, c->sourceChannelIndex);
 860             comp->setOutput (c->destNodeId, c->destChannelIndex);
 861         }
 862     }
 863 }
 864
 865 void GraphEditorPanel::beginConnectorDrag (const uint32 sourceFilterID, const int sourceFilterChannel,
 866                                            const uint32 destFilterID, const int destFilterChannel,
 867                                            const MouseEvent& e)
 868 {
 869     delete draggingConnector;
 870     draggingConnector = dynamic_cast <ConnectorComponent*> (e.originalComponent);
 871
 872     if (draggingConnector == nullptr)
 873         draggingConnector = new ConnectorComponent (graph);
 874
 875     draggingConnector->setInput (sourceFilterID, sourceFilterChannel);
 876     draggingConnector->setOutput (destFilterID, destFilterChannel);
 877
 878     addAndMakeVisible (draggingConnector);
 879     draggingConnector->toFront (false);
 880
 881     dragConnector (e);
 882 }
 883
 884 void GraphEditorPanel::dragConnector (const MouseEvent& e)
 885 {
 886     const MouseEvent e2 (e.getEventRelativeTo (this));
 887
 888     if (draggingConnector != nullptr)
 889     {
 890         draggingConnector->setTooltip (String::empty);
 891
 892         int x = e2.x;
 893         int y = e2.y;
 894
 895         PinComponent* const pin = findPinAt (x, y);
 896
 897         if (pin != nullptr)
 898         {
 899             uint32 srcFilter = draggingConnector->sourceFilterID;
 900             int srcChannel = draggingConnector->sourceFilterChannel;
 901             uint32 dstFilter = draggingConnector->destFilterID;
 902             int dstChannel = draggingConnector->destFilterChannel;
 903
 904             if (srcFilter == 0 && ! pin->isInput)
 905             {
 906                 srcFilter = pin->filterID;
 907                 srcChannel = pin->index;
 908             }
 909             else if (dstFilter == 0 && pin->isInput)
 910             {
 911                 dstFilter = pin->filterID;
 912                 dstChannel = pin->index;
 913             }
 914
 915             if (graph.canConnect (srcFilter, srcChannel, dstFilter, dstChannel))
 916             {
 917                 x = pin->getParentComponent()->getX() + pin->getX() + pin->getWidth() / 2;
 918                 y = pin->getParentComponent()->getY() + pin->getY() + pin->getHeight() / 2;
 919
 920                 draggingConnector->setTooltip (pin->getTooltip());
 921             }
 922         }
 923
 924         if (draggingConnector->sourceFilterID == 0)
 925             draggingConnector->dragStart (x, y);
 926         else
 927             draggingConnector->dragEnd (x, y);
 928     }
 929 }
 930
 931 void GraphEditorPanel::endDraggingConnector (const MouseEvent& e)
 932 {
 933     if (draggingConnector == nullptr)
 934         return;
 935
 936     draggingConnector->setTooltip (String::empty);
 937
 938     const MouseEvent e2 (e.getEventRelativeTo (this));
 939
 940     uint32 srcFilter = draggingConnector->sourceFilterID;
 941     int srcChannel = draggingConnector->sourceFilterChannel;
 942     uint32 dstFilter = draggingConnector->destFilterID;
 943     int dstChannel = draggingConnector->destFilterChannel;
 944
 945     deleteAndZero (draggingConnector);
 946
 947     PinComponent* const pin = findPinAt (e2.x, e2.y);
 948
 949     if (pin != nullptr)
 950     {
 951         if (srcFilter == 0)
 952         {
 953             if (pin->isInput)
 954                 return;
 955
 956             srcFilter = pin->filterID;
 957             srcChannel = pin->index;
 958         }
 959         else
 960         {
 961             if (! pin->isInput)
 962                 return;
 963
 964             dstFilter = pin->filterID;
 965             dstChannel = pin->index;
 966         }
 967
 968         graph.addConnection (srcFilter, srcChannel, dstFilter, dstChannel);
 969     }
 970 }
 971
 972
 973 //==============================================================================
 974 class TooltipBar   : public Component,
 975                      private Timer
 976 {
 977 public:
 978     TooltipBar()
 979     {
 980         startTimer (100);
 981     }
 982
 983     void paint (Graphics& g)
 984     {
 985         g.setFont (getHeight() * 0.7f, Font::bold);
 986         g.setColour (Colours::black);
 987         g.drawFittedText (tip, 10, 0, getWidth() - 12, getHeight(), Justification::centredLeft, 1);
 988     }
 989
 990     void timerCallback()
 991     {
 992         Component* const underMouse = Desktop::getInstance().getMainMouseSource().getComponentUnderMouse();
 993         TooltipClient* const ttc = dynamic_cast <TooltipClient*> (underMouse);
 994
 995         String newTip;
 996
 997         if (ttc != nullptr && ! (underMouse->isMouseButtonDown() || underMouse->isCurrentlyBlockedByAnotherModalComponent()))
 998             newTip = ttc->getTooltip();
 999
1000         if (newTip != tip)
1001         {
1002             tip = newTip;
1003             repaint();
1004         }
1005     }
1006
1007 private:
1008     String tip;
1009
1010     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TooltipBar);
1011 };
1012
1013 //==============================================================================
1014 GraphDocumentComponent::GraphDocumentComponent (AudioDeviceManager* deviceManager_)
1015     : deviceManager (deviceManager_)
1016 {
1017     addAndMakeVisible (graphPanel = new GraphEditorPanel (graph));
1018
1019     graphPlayer.setProcessor (&graph.getGraph());
1020
1021     keyState.addListener (&graphPlayer.getMidiMessageCollector());
1022
1023     addAndMakeVisible (keyboardComp = new MidiKeyboardComponent (keyState,
1024                                                                  MidiKeyboardComponent::horizontalKeyboard));
1025
1026     addAndMakeVisible (statusBar = new TooltipBar());
1027
1028     deviceManager->addAudioCallback (&graphPlayer);
1029     deviceManager->addMidiInputCallback (String::empty, &graphPlayer.getMidiMessageCollector());
1030
1031     graphPanel->updateComponents();
1032 }
1033
1034 GraphDocumentComponent::~GraphDocumentComponent()
1035 {
1036     deviceManager->removeAudioCallback (&graphPlayer);
1037     deviceManager->removeMidiInputCallback (String::empty, &graphPlayer.getMidiMessageCollector());
1038
1039     deleteAllChildren();
1040
1041     graphPlayer.setProcessor (nullptr);
1042     keyState.removeListener (&graphPlayer.getMidiMessageCollector());
1043
1044     graph.clear();
1045 }
1046
1047 void GraphDocumentComponent::resized()
1048 {
1049     const int keysHeight = 60;
1050     const int statusHeight = 20;
1051
1052     graphPanel->setBounds (0, 0, getWidth(), getHeight() - keysHeight);
1053     statusBar->setBounds (0, getHeight() - keysHeight - statusHeight, getWidth(), statusHeight);
1054     keyboardComp->setBounds (0, getHeight() - keysHeight, getWidth(), keysHeight);
1055 }
1056
1057 void GraphDocumentComponent::createNewPlugin (const PluginDescription* desc, int x, int y)
1058 {
1059     graphPanel->createNewPlugin (desc, x, y);
1060 }